
export default class ObjectUtils {

    static formatString(str: string, ...data: any[]) {
        if (data == null) {
            return;
        }

        for (let i = 0; i < data.length; i++) {
            str = str.replace(/{[0-9]|[1-9][0-9]}|%s|%d/i, data[i]);
        }

        return str
    }


    static padStart(num: number, len: number = 2, sign: string = "0") {
        let str = num.toString(), size = str.length;
        if (size >= len) {
            return str.substring(0, len);
        }

        return this.getSing(sign, len - size) + str;

    }

    static padEnd(num: number, len: number = 2, sign: string = "0") {
        let str = num.toString(), size = str.length;
        if (size >= len) {
            return str.substring(0, len);
        }

        return str + this.getSing(sign, len - size);
    }

    static getSing(sing: string, num: number) {
        let strs = [];
        for (let i = 0; i < num; i++) {
            strs.push(sing);
        }

        return strs.join();
    }


    static equal(obj1: object, obj2: object, key: string) {

        return obj1[key] === obj2[key];
    }

    /**
     * 数组去重，会重新排序
     * @param arr 
     * @returns 
     */
    static unique<T>(arr: T[]) {
        arr.sort();
        let arrry = [arr[0]];

        for (let i = 1; i < arr.length; i++) {
            if (arr[i] !== arr[i - 1]) {
                arrry.push(arr[i]);
            }
        }
        return arrry;
    }

    /**
     * 数组去重
     * @param arr 
     * @returns 
     */
    static uniqueUnSort<T>(arr: T[]) {
        let array = [];
        for (let i = 0; i < arr.length; i++) {
            if (array.indexOf(arr[i]) !== -1) {
                array.push(arr[i]);
            }
        }

        return array;
    }

    // static getOrDefine(obj: object, k: string, v?: any) {
    //     if (v == null) {
    //         obj[k] = v;
    //         return v;
    //     }

    //     return obj[k];
    // }

    /**
     * 防抖函数，返回函数连续调用时，空闲时间必须大于或等于 wait，func 才会执行
     *
     * @param  {function} func        回调函数
     * @param  {number}   wait        表示时间窗口的间隔
     * @param  {boolean}  immediate   设置为ture时，是否立即调用函数
     * @return {function}             返回客户调用函数
     */
    static debounce(func, wait = 50, immediate = true) {
        let timer, context, args
        // 延迟执行函数
        const later = () => setTimeout(() => {
            // 延迟函数执行完毕，清空缓存的定时器序号
            timer = null
            // 延迟执行的情况下，函数会在延迟函数中执行
            // 使用到之前缓存的参数和上下文
            if (!immediate) {
                func.apply(context, args)
                // func.run();
                context = args = null
            }
        }, wait)

        // 这里返回的函数是每次实际调用的函数
        return function (...params) {
            // 如果没有创建延迟执行函数（later），就创建一个
            if (!timer) {
                timer = later()
                // 如果是立即执行，调用函数
                // 否则缓存参数和调用上下文
                if (immediate) {
                    func.apply(this, params)
                    // func.run();
                } else {
                    context = this
                    args = params
                }
                // 如果已有延迟执行函数（later），调用的时候清除原来的并重新设定一个
                // 这样做延迟函数会重新计时
            } else {
                clearTimeout(timer)
                timer = later()
            }
        }
    }


}